package com.asa.group;

import java.util.ArrayList;

/**
 * 正规子群
 * 
 * 定义4. （正规子群）设 H 是群 G 的子群。若对任意 g属于G，gH=Hg ，则称 H 是 G 的正规子群或不变子群。
 * 
 * 
 * 这里的gH = Hg有点可疑，H是群而g是G中的一个元素，那么它们之间是怎样的运算关系呢？
 * 我猜一下，即g对H中的每个元素进行计算，然后得出来一个元素集合，gH和Hg是指元素与g运算得次序
 * gH = Hg表示它们最后生成出来得集合是相等的
 * 
 * gH并不一定是个群，它是群的充要条件是，g属于G的同时g也属于H
 * 
 * H是G的正规子群的符号 H⊲G
 * 
 * gH这种称之为g是左陪，gH称之为左陪集
 * Hg这种称之为g是右陪，Hg称之为右陪集
 * 
 * 
 * 需要补充一下容易混乱得地方，gH得计算是默认得g与H中每个元素得计算，这个计算是群里面的计算，是默认得
 * 
 * 
 * 
 * @author asa
 *
 *
 *性质：
 *	f:G->H群同态
 *	ker(f)是G的正规子群
 *
 *
 *
 *
 */
public class GroupSon {
	
	
	
	/**
	 * 提前默认了list1是list2的子群，这里只判断正规性
	 * 判断list1是不是list2的正规子群
	 * 
	 * @param <T>
	 * @param list1
	 * @param list2
	 * @param asa
	 * @param e
	 * @return
	 */
	public static <T> boolean isGroupSon(ArrayList<T> list1,ArrayList<T> list2,ObjectFunction<T> asa,T e) {
		
	
		for (int i = 0; i < list2.size(); i++) {
			T t = list2.get(i);
			ArrayList<T> buffer1 = new ArrayList<T>();
			ArrayList<T> buffer2 = new ArrayList<T>();

			for (int j = 0; j < list1.size(); j++) {
				T t2 = list1.get(j);
				T hanshu1 = asa.hanshu(t, t2);
				
				T hanshu2 = asa.hanshu(t2, t);

				buffer1.add(hanshu1);
				buffer2.add(hanshu2);
				
			}
			
			
			for (int j = 0; j < buffer1.size(); j++) {
				
				T t2 = buffer1.get(j);
				boolean contains = buffer2.contains(t2);
				if (!contains) {
					return false;
				}
				
			}
			
			if (buffer1.size()!=buffer2.size()) {
				return false;
			}
			
			
		}
		
		return true;
	}
	
	
	
	/**
	 * 第一同构定理
	 * 
	 * 设G，H为两个群，设f:G→H为一个群同态。则 ker(f) 是 G 的正规子群
	 * 并且G/ker(f) 群同构于  im(f) = f(G)
	 * 
	 *  
	 * G/ker(f)是指商群，是指G的所有元素，左陪集核的集合，研究点可以查看商群的定义
	 * 
	 * 
	 * 
	 * 证明会很麻烦(根据定义来理解)
	 * 我直接说一下直观，G/ker(f) 同构于 im(g)，其实G/ker(f)可以理解为G的一个线性组合a0x0 , a1x1,... ,anxn ，其中x是G中元素，而ker(f)是a，可以构建出一个nXm的矩阵出来
	 * 
	 * 也就是说 G/ker(f)是一个线性组合，那么它同构于f的像，这些像是H里面的元素。
	 * G/ker(f)类型归一化处理，im(f)把不相干的映射剔除了，相当于G和H都把自身影响同构的元素水分挤掉了（这个挤水分的过程G/ker(f)较难理解，想到这个的人是怎么个思路未知）
	 * 
	 * 换句话说可以说G剔除了核相关映射得出的线性组合可以同构于H的像
	 * 更直观一点的说法是G与H是同态的，那么G与核进行运算与像是对应的，
	 * 
	 * 这可以带来一个效果，那就是两个群是群同态可以通过G对核进行运算得出一个新的群，并用它与像来生成一个群同构
	 * 
	 * 
	 * 
	 * 
	 * 
	 */
	
	
	
	

}
